package com.wxapp.system.service.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.wxapp.common.constant.base.IBaseService;
import com.wxapp.common.constant.pojo.vm.ResultVm;
import com.wxapp.common.constant.pojo.vo.UserVo;
import com.wxapp.common.util.check.CheckUtil;
import com.wxapp.common.util.condition.ConditionUtil;
import com.wxapp.common.util.copy.CopyUtil;
import com.wxapp.system.api.pojo.entity.DictKeyDO;
import com.wxapp.system.api.pojo.entity.DictValueDO;
import com.wxapp.system.api.pojo.vm.dict.value.PDictValueDetailVm;
import com.wxapp.system.api.pojo.vm.dict.value.PDictValuePage;
import com.wxapp.system.api.pojo.vm.dict.value.QDictValueSelectVm;
import com.wxapp.system.api.pojo.vo.dict.value.QDictValuePageVo;
import com.wxapp.system.api.pojo.vo.dict.value.QDictValueSaveVo;
import com.wxapp.system.api.pojo.vo.dict.value.QDictValueUpdateVo;
import com.wxapp.system.service.mapper.DictKeyMapper;
import com.wxapp.system.service.mapper.DictValueMapper;
import com.wxapp.system.service.service.DictValueService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * @author lgl
 * @Description 字典类
 * @Datetime 2022/5/30 9:40
 * @Modified By
 */
@Service
@RequiredArgsConstructor
public class DictValueServiceImpl extends IBaseService implements DictValueService {
    private final DictValueMapper dictValueMapper;
    private final DictKeyMapper dictKeyMapper;
    @Override
    public ResultVm<String> deleteDictValue(String id) {
        var dictKeyDO = dictValueMapper.selectById(id);
        if (CheckUtil.isNullObject(dictKeyDO)) {
            return error("没有找到该字典值");
        }
        LambdaUpdateWrapper<DictValueDO> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(DictValueDO::getStatus, true).eq(DictValueDO::getId, id).set(DictValueDO::getStatus, false);
        dictValueMapper.update(null, wrapper);
        return success();
    }

    @Override
    public ResultVm<Page<PDictValuePage>> pageDictValue(QDictValuePageVo qSaveVo) {
        Page<PDictValuePage> pPageVmPage = dictValueMapper.pageDictValue(ConditionUtil.getPage(qSaveVo, DictValueDO.class), qSaveVo);
        return success(pPageVmPage);
    }


    @Override
    public ResultVm<PDictValueDetailVm> detailDictValue(String id) {
        var dictKeyDO = dictValueMapper.selectById(id);
        if (CheckUtil.isNullObject(dictKeyDO)) {
            return error("没有找到该字典值");
        }
        return success(CopyUtil.copyObjectNew(dictKeyDO, PDictValueDetailVm::new, null));
    }

    @Override
    public ResultVm<String> updateDictValue(UserVo userVo, QDictValueUpdateVo qSaveVo) {
        var dictValueDO = dictValueMapper.selectById(qSaveVo.getId());
        if (CheckUtil.isNullObject(dictValueDO)) {
            return error("查询到该字典信息");
        }
        var dictValue = CopyUtil.copyObjectNew(qSaveVo, DictValueDO::new, (s, r) -> {
            r.setUpdateBy(userVo.getId());
            return null;
        });
        dictValueMapper.updateById(dictValue);
        return success("更新成功");
    }

    @Override
    public ResultVm<String> saveDictValue(UserVo userVo, QDictValueSaveVo qDictValueSaveVo) {
        LambdaQueryWrapper<DictValueDO> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DictValueDO::getStatus, true).eq(DictValueDO::getDictValue, qDictValueSaveVo.getDictValue());
        var selectCount = dictValueMapper.selectCount(wrapper);
        if (selectCount > 0) {
            return error("已存在该名称的字典");
        }
        var dictValueDO = CopyUtil.copyObjectNew(qDictValueSaveVo, DictValueDO::new, (s, r) -> {
            r.setCreateBy(userVo.getId());
            return null;
        });
        dictValueMapper.insert(dictValueDO);
        return success("保存成功");
    }

    @Override
    public ResultVm<List<QDictValueSelectVm>> getSelect(String dictKey) {
        LambdaQueryWrapper<DictKeyDO> query = new LambdaQueryWrapper<>();
        query.eq(DictKeyDO::getStatus, true)
                .eq(DictKeyDO::getDictKey, dictKey);
        var selectCount = dictKeyMapper.selectFirst(query);
        if (CheckUtil.isNullObject(selectCount)){
            return error("没有找到字典值");
        }
        LambdaQueryWrapper<DictValueDO> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DictValueDO::getStatus, true)
                .select(DictValueDO::getDictValue, DictValueDO::getDictName)
                .eq(DictValueDO::getKeyId, selectCount.getId());
        var dictKeyDOS = dictValueMapper.selectList(wrapper);
        List<QDictValueSelectVm> result=new ArrayList<>();
        dictKeyDOS.forEach(s-> result.add(new QDictValueSelectVm(s.getDictName(),s.getDictValue())));
        return success(result);
    }
}
